Extrahierte Daten speichern

Was du nach diesem Kapitel kannst: Du kannst eine Datenbankstruktur für extrahierte Dokumentdaten entwerfen, Tabellen im Internal Storage anlegen und einen Workflow so erweitern, dass er Daten per Internal Storage Agent in die Datenbank schreibt und wieder ausliest.

1. Warum Daten speichern?

In den vorangegangenen Kapiteln hast du gelernt, wie man Dokumente kategorisiert und strukturierte Daten daraus extrahiert. Am Ende des Extraktions-Workflows stehen die Daten als JSON in der Nachricht — aber nur dort. Sobald der Workflow-Durchlauf endet, sind die Daten weg.

In der Praxis reicht das selten aus. Typische Anforderungen:

Weiterverarbeitung in späteren Schritten — ein anderer Workflow-Abschnitt soll auf die extrahierten Daten zugreifen, ohne die gesamte Extraktion zu wiederholen
Dublettenprüfung — vor der Verarbeitung prüfen, ob ein Dokument bereits verarbeitet wurde
Auswertung und Überblick — eine Tabelle aller verarbeiteten Bestellungen einsehen können
Übergabe an Folgesysteme — Daten gesammelt und strukturiert an ein ERP oder eine API übergeben

Die Lösung: Daten in den Internal Storage schreiben — die plattformeigene SQLite-Datenbank von 42°OS.

2. Szenario: Bestelldaten aus einer PDF speichern

Wir knüpfen direkt an den Extraktions-Workflow aus dem vorherigen Kapitel an. Der Workflow hat eine Bestell-PDF gelesen und per Generative AI Agent folgende Daten extrahiert:

{
  "dokument_id": "B-2026-0042",
  "lieferant": "Müller Industriebedarf GmbH",
  "bestelldatum": "2026-03-15",
  "positionen": [
    {
      "artikelnummer": "MI-7820",
      "beschreibung": "Hydraulikschlauch DN12, 2m",
      "menge": "10 ST",
      "einzelpreis": 24.50
    },
    {
      "artikelnummer": "MI-3201",
      "beschreibung": "Dichtungsring NBR 18x3",
      "menge": "50 ST",
      "einzelpreis": 0.85
    }
  ]
}

Ziel: Diese Daten sollen strukturiert in der Datenbank landen — Kopfdaten und Positionen getrennt, damit sie einzeln abfragbar sind.

3. Schritt 1 — Datenbankstruktur entwerfen

Bevor du Daten schreiben kannst, brauchst du Tabellen. Die wichtigste Entscheidung: Welche Daten gehören in welche Tabelle?

Faustregel: Wenn ein Datensatz mehrere gleichartige Unterpunkte hat (wie Positionen in einer Bestellung), trenne sie in eine eigene Tabelle. Das ermöglicht spätere Abfragen auf Positionsebene.

Für unser Szenario brauchen wir zwei Tabellen:

Tabelle bestellungen — Kopfdaten pro Dokument:

CREATE TABLE bestellungen (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  dokument_id TEXT NOT NULL,
  lieferant TEXT,
  bestelldatum TEXT,
  dateiname TEXT,
  status TEXT DEFAULT 'extrahiert',
  erstellt_am TEXT DEFAULT (datetime('now'))
);

Tabelle bestellpositionen — eine Zeile pro Position:

CREATE TABLE bestellpositionen (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  dokument_id TEXT NOT NULL,
  artikelnummer TEXT,
  beschreibung TEXT,
  menge TEXT,
  einzelpreis REAL,
  erstellt_am TEXT DEFAULT (datetime('now'))
);

💡 Das Feld dokument_id verknüpft beide Tabellen. So kannst du später alle Positionen zu einer bestimmten Bestellung abfragen.

4. Schritt 2 — Tabellen im Internal Storage anlegen

Tabellen werden nicht im Workflow angelegt, sondern über den Internal-Storage-Bereich in der Plattform-Oberfläche.

Öffne den Internal-Storage-Bereich
Gib das CREATE TABLE-Statement in das Texteingabefeld ein
Bestätige — die Tabelle erscheint in der Tabellenliste
Wiederhole den Vorgang für die zweite Tabelle

📸 Screenshot: [Platzhalter — Internal-Storage-Bereich: CREATE TABLE Statement eingeben]

📸 Screenshot: [Platzhalter — Tabellenliste mit den beiden neuen Tabellen]

Per Klick auf einen Tabellennamen in der Liste kannst du die Spalten und vorhandenen Einträge einsehen.

📸 Screenshot: [Platzhalter — Spaltenansicht der Tabelle bestellungen]

🔗 Referenz: Internal Storage beschreibt die Oberfläche und SQLite-Besonderheiten im Detail.

5. Schritt 3 — Daten in die Datenbank schreiben

Der Internal Storage Agent schreibt Daten per SQL-Statement in die Datenbank. Werte aus der Nachricht werden per Liquid Templating eingesetzt.

Kopfdaten schreiben

Ein Internal Storage Agent mit folgendem Statement schreibt die Kopfdaten:

INSERT INTO bestellungen (dokument_id, lieferant, bestelldatum, dateiname)
VALUES ('{{ dokument_id }}', '{{ lieferant }}', '{{ bestelldatum }}', '{{ filename }}');

📸 Screenshot: [Platzhalter — Internal Storage Agent Konfiguration: INSERT für Kopfdaten]

Positionen schreiben

Für die Positionen brauchst du einen zusätzlichen Schritt: Da die Nachricht ein Array von Positionen enthält, muss dieses Array zuerst per JSON Split Agent vereinzelt werden. Anschließend schreibt ein Internal Storage Agent jede Position einzeln:

INSERT INTO bestellpositionen (dokument_id, artikelnummer, beschreibung, menge, einzelpreis)
VALUES ('{{ dokument_id }}', '{{ artikelnummer }}', '{{ beschreibung }}', '{{ menge }}', {{ einzelpreis }});

[JSON Parse Agent]
      ↓
[Internal Storage Agent]   →  Kopfdaten schreiben
      ↓
[JSON Split Agent]         →  Positionen-Array vereinzeln
      ↓
[Internal Storage Agent]   →  je eine Position schreiben

📹 Video: [Platzhalter — Screencast: Extraktions-Workflow um Internal Storage Agent erweitern]

6. Schritt 4 — Daten aus der Datenbank abrufen

Der Internal Storage Agent liest Daten genauso wie er sie schreibt — mit einem SQL-Statement. Das Ergebnis wird als JSON-Array unter dem Schlüssel result in die Nachricht geschrieben.

Alle Bestellungen eines Lieferanten abrufen

SELECT dokument_id, lieferant, bestelldatum, status
FROM bestellungen
WHERE lieferant = '{{ lieferant }}'
ORDER BY bestelldatum DESC;

Alle Positionen einer Bestellung abrufen

SELECT artikelnummer, beschreibung, menge, einzelpreis
FROM bestellpositionen
WHERE dokument_id = '{{ dokument_id }}';

Prüfen ob ein Dokument bereits verarbeitet wurde

SELECT COUNT(*) AS anzahl
FROM bestellungen
WHERE dokument_id = '{{ dokument_id }}';

💡 Eine Dublettenprüfung am Anfang des Workflows verhindert, dass dasselbe Dokument mehrfach verarbeitet wird. Wenn anzahl > 0, kann der Workflow den Durchlauf abbrechen oder eine Benachrichtigung auslösen.

7. Zusammenfassung

Schritt	Was passiert	Agent
Struktur entwerfen	Tabellen und Spalten definieren	— (Entwurfsarbeit)
Tabellen anlegen	CREATE TABLE im Internal-Storage-Bereich	— (Plattform-UI)
Kopfdaten schreiben	INSERT mit Liquid-Werten	Internal Storage Agent
Positionen vereinzeln	Array in Einzelnachrichten aufteilen	JSON Split Agent
Positionen schreiben	INSERT pro Position	Internal Storage Agent
Daten abrufen	SELECT mit Filterbedingung	Internal Storage Agent

🔗 Vertiefung: Zustandsnormalisierung durch SQL-Persistenz erklärt wann und warum SQL-Persistenz als Entwurfsmuster sinnvoll ist.

🔗 Referenz: SQL — Daten abfragen und schreiben beschreibt die SQL-Syntax im Detail.

1. Warum Daten speichern?​

2. Szenario: Bestelldaten aus einer PDF speichern​

3. Schritt 1 — Datenbankstruktur entwerfen​

4. Schritt 2 — Tabellen im Internal Storage anlegen​

5. Schritt 3 — Daten in die Datenbank schreiben​

Kopfdaten schreiben​

Positionen schreiben​

6. Schritt 4 — Daten aus der Datenbank abrufen​

Alle Bestellungen eines Lieferanten abrufen​

Alle Positionen einer Bestellung abrufen​

Prüfen ob ein Dokument bereits verarbeitet wurde​

7. Zusammenfassung​